home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d919.lha / TxtCvt / readms.c < prev    next >
C/C++ Source or Header  |  1993-10-04  |  3KB  |  196 lines
  1. #include "txtcvt.h"
  2.  
  3. /**********************************
  4.     Get 2-byte lohi value from file
  5. ***********************************/
  6.  
  7. int get2byte(FILE *ifp, int offset)
  8. {
  9.     int value = -1;
  10.     int r;
  11.     int hi;
  12.     int lo;
  13.  
  14.     r = fseek(ifp, offset, SEEK_SET);
  15.     if(r != -1)    {
  16.         lo = fgetc(ifp);
  17.         if(lo != EOF) {
  18.             hi = fgetc(ifp);
  19.             if(hi != EOF) {
  20.                 value = hi * 256 + lo;
  21.             }
  22.         }
  23.     }
  24.     return(value);
  25. }
  26.     
  27. /********************************
  28.     Read Microsoft text file
  29. ********************************/
  30.  
  31. void readmsfile(FILE *ifp, FILE *ofp, int filetype)
  32. {
  33.     unsigned int c;
  34.     int r;
  35.     int size;
  36.     int offset;
  37.     int hdrsize;
  38.     int textoffset;
  39.     int written;
  40.  
  41.     switch (filetype) {
  42.         case DOSWORD: {
  43.             offset = 14;
  44.             hdrsize = 128;
  45.             break;
  46.         }
  47.         case WINWORD1: {
  48.             offset = 28;
  49.             hdrsize = 384;
  50.             break;
  51.         }
  52.         case WINWORD2: {
  53.             offset = 28;
  54.             hdrsize = 384;
  55.             break;
  56.         }
  57.         case WINWRITE: {
  58.             offset = 14;
  59.             hdrsize = 128;
  60.             break;
  61.         }
  62.     }
  63.  
  64.     size = get2byte(ifp, offset) - hdrsize;
  65.     if(size == 0) {
  66.         printf("Unable to process inputfile\n");
  67.     }
  68.     else {
  69.         printf("Length of text: %i\n", size);
  70.     }
  71.  
  72.     switch (filetype) {
  73.         case DOSWORD: {
  74.             textoffset = 128;
  75.             break;
  76.         }
  77.         case WINWORD1: {
  78.             textoffset = get2byte(ifp, 24);
  79.             break;
  80.         }
  81.         case WINWORD2: {
  82.             textoffset = get2byte(ifp, 24);
  83.             break;
  84.         }
  85.         case WINWRITE: {
  86.             textoffset = 128;
  87.             break;
  88.         }
  89.     }
  90.     if(textoffset == 0) {
  91.         printf("Unable to process inputfile\n");
  92.     }
  93.     else {
  94.         printf("Start of text: %i\n", textoffset);
  95.     }
  96.  
  97.     r = fseek(ifp, textoffset, SEEK_SET);
  98.     if(r != -1)    {
  99.         c = fgetc(ifp);
  100.         r = 0;
  101.         written = 0;
  102.         while(c != EOF && r != EOF && written < size) {
  103.             written++;
  104.             switch (c) {
  105.                 case 0:
  106.                 case 1:
  107.                 case 2:
  108.                 case 3:
  109.                 case 4:
  110.                 case 5:
  111.                 case 6:    
  112.                 case 7:
  113.                 case 8:
  114.                 case 12:            /* explicit page break */ 
  115.                 case 14:
  116.                 case 16:
  117.                 case 17:
  118.                 case 18:
  119.                 case 19:
  120.                 case 20:
  121.                 case 21:
  122.                 case 22:
  123.                 case 23:
  124.                 case 24:
  125.                 case 25:
  126.                 case 26:
  127.                 case 27:
  128.                 case 28:
  129.                 case 29:
  130.                 case 31:
  131.                     break;
  132.                 case 11: {            /* Hard line break */
  133.                     r = fputc(13, ofp);
  134.                     if(r != EOF) {
  135.                         r = fputc(10, ofp);
  136.                     }
  137.                     break;
  138.                 }
  139.                 case 15: {            /* em-hyphen to hyphen */
  140.                     if(filetype == DOSWORD || filetype == WINWORD1 || filetype == WINWORD2) {
  141.                         r = fputc(45, ofp);
  142.                         if(r != EOF) {
  143.                             r = fputc(45, ofp);
  144.                         }
  145.                     }
  146.                     break;
  147.                 }
  148.                 case 30: {            /* nonbreaking hyphen */
  149.                     if(filetype == WINWORD1 || filetype == WINWORD2) {
  150.                         r = fputc(45, ofp);
  151.                     }
  152.                     break;
  153.                 }
  154.                 case 160: {            /* nonbreaking space */
  155.                     if(filetype == WINWORD1 || filetype == WINWORD2) {
  156.                         r = fputc(32, ofp);
  157.                     }
  158.                     else {
  159.                         r = fputc(c, ofp);
  160.                     }
  161.                     break;
  162.                 }
  163.                 case 196: {            /* nonbreaking hyphen */
  164.                     if(filetype == DOSWORD) {
  165.                         r = fputc(45, ofp);
  166.                     }
  167.                     else {
  168.                         r = fputc(c, ofp);
  169.                     }
  170.                     break;
  171.                 }
  172.                 case 255: {            /* nonbreaking space */
  173.                     if(filetype == DOSWORD) {
  174.                         r = fputc(32, ofp);
  175.                     }
  176.                     else {
  177.                         r = fputc(c, ofp);
  178.                     }
  179.                     break;
  180.                 }
  181.                 default: {
  182.                     r = fputc(c, ofp);
  183.                     break;
  184.                 }
  185.             }
  186.             c = fgetc(ifp);
  187.         }
  188.         if(r == EOF) {
  189.             printf("Error %d occurred while writing to outputfile.\n",errno);
  190.         }
  191.     }
  192.     else {
  193.         printf("Unable to process inputfile\n");
  194.     }
  195. }
  196.